home *** CD-ROM | disk | FTP | other *** search
/ MacFormat España 15 / macformat_15.iso / C de cerca / Ejemplos / Capítulo 2 / CdeCerca.c < prev   
C/C++ Source or Header  |  1996-02-24  |  8KB  |  251 lines
  1. /*****************************************************************/
  2. /*
  3.         C de Cerca 2
  4.         Funciones, parámetros y texto en el Mac
  5.             
  6.             Rafael Escoté - Enric Herrera
  7.             BlauSoft S.L. para MacFormat España - 1996
  8.                     
  9.             La descripción del código y la información sobre cómo preparar
  10.             el entorno de programación y generar estos programas, está contenida
  11.             en el ejemplar de MacFormat que los acompaña.
  12.  
  13. */
  14. /*****************************************************************/
  15.  
  16.  
  17.  
  18. /****************************************************************    */
  19. /* PROTOTIPOS    DE LAS FUNCIONES QUE HEMOS CREADO                                         */
  20. /* PARA NUESTRO PROGRAMA                                                                                    */ 
  21. /****************************************************************    */
  22. void        main(void);                /* Esta función NO puede tener otro nombre */
  23. void        MF_InitToolbox         (void);
  24. void         MF_AbreMiVentana    (void);
  25. void         MF_EscribeTexto        (short codigo);
  26. void         MF_bucle_principal(void);
  27.  
  28.  
  29.  
  30. /****************************************************************    */
  31. /* CONSTANTES Y VARIABLES GLOBALES                                                                 */
  32. /* RELACIONADAS CON LA VENTANA QUE ABRIREMOS                                            */ 
  33. /****************************************************************    */
  34. /* La ventana que abriremos será creada dinámicamente por medio de
  35. la función NewWindow() que nos devolverá un puntero a la estructura de
  36. la nueva ventana, Declaramos pues, una variable adecuada... */
  37.     
  38. WindowPtr        gMiVentana = nil;
  39.                                                                 
  40.  
  41.  
  42. /*--------------------------------------------------------------------*/
  43. /* A PARTIR DE ESTE PUNTO, APARECE EL CODIGO DE LAS FUNCIONES CREADAS
  44.      ESPECIFICAMENTE PARA ESTE PROGRAMA. */
  45. /*--------------------------------------------------------------------*/
  46.  
  47.  
  48.  
  49. /****************************************************************    */
  50. /* main()                                                                 */
  51. /****************************************************************    */
  52. /*
  53.     Todos los programas en C poseen una función que debe llamarse main.
  54.     Cuando un programa se pone en marcha, lo hace SIEMPRE ejecutando
  55.     en primer lugar la función main().
  56.     Es el punto de entrada a nuestra aplicación.
  57.     
  58.     Recibe:     nada
  59.     Que hace: Llama otras funciones que preparan la aplicación...
  60.     Salida:      void (nada)
  61. */
  62. void    main (void)
  63. {    
  64.     /* Antes de hacer nada, debemos inicializar la Toolbox del Mac                 */
  65.     /* Como sea que el procedimiento a seguir para inicializar la Toolbox */
  66.     /* es casi siempre el mismo, hemos creado una función MF_InitToolbox()*/
  67.     /* que contiene las llamadas estándar de inicialización */
  68.  
  69.     MF_InitToolbox();
  70.     
  71.     /* Ahora empleamos una función que se encargará de abrir una ventana */
  72.     MF_AbreMiVentana();
  73.     
  74.     /* Una vez abierta la ventana, podemos escribir algo de texto en ella */
  75.     MF_EscribeTexto(0);
  76.     
  77.     /* Y ya podemos entrar en el bucle principal, que se encargará de
  78.          recoger e interpretar las acciones del usuario */    
  79.     MF_bucle_principal();
  80.     
  81.     /* Cuando el bucle principal haya terminado, será porque el usuario
  82.          desea acabar el programa.
  83.          Debemos liberar la memoria ocupada por nuestra ventana. */
  84.     DisposeWindow(gMiVentana);
  85.     
  86.   /* Y ya está, al acabarse la función main(), el Sistema cerrará
  87.          nuestra aplicación de forma automática */
  88.     
  89. } /* Fin de main() y del programa */
  90.  
  91.  
  92.  
  93. /****************************************************************    */
  94. /* MF_bucle_principal                                                     */
  95. /****************************************************************    */
  96. /*
  97.     Recibe:     nada
  98.     Que hace: Entra en un bucle y espera que se produzca una acción
  99.                         Según cual sea esta, reacciona llamando una de las funciones que
  100.                         hemos creado en esta demo.
  101.     Salida:      nada
  102. */
  103. void MF_bucle_principal(void)
  104. {
  105.     short contador = 1; /* declaramos e inicializamos una variable 
  106.                                                  que nos servirá para contar las veces que 
  107.                                                  ejecutaremos la función MF_EscribeTexto()
  108.                                             */
  109.                                             
  110.     long    dummy;                /* Una variable long que la función Delay()    requiere */
  111.     
  112.     /* Mientras contador sea menor o igual a 3 */
  113.     while(contador <= 3)
  114.     {
  115.     
  116.         while (Button() == 0) 
  117.                 ;    /* Nos paramos a esperar que sea pulsado el ratón
  118.                          Button() es una función que devuelve el valor 0 si el botón 
  119.                          del ratón no está pulsado */
  120.         
  121.         MF_EscribeTexto(contador);    /* OK. Han pulsado el botón
  122.                                                                     Ejecutamos la función MF_EscribeTExto()
  123.                                                                     pasandole el valor de contador.
  124.                                                                     La primera vez será = 1, luego 2 etc... */
  125.                                                                 
  126.         Delay(30,&dummy);            /*  Delay() es una función del Mac que detiene
  127.                                                             todo proceso durante el tiempo indicado en
  128.                                                             su primer parámetro. Las unidades empleadas
  129.                                                             son 1/60" seg.
  130.                                                             Así pues, 30 equivale a medio segundo de espera */
  131.                                                             
  132.         contador = contador+1;/* Ahora incrementamos el contador sumándole 1.*/
  133.         
  134.     } /* fin del bucle while(contador <= 3) */
  135.     
  136.     Delay(60,&dummy); /* Un poco más de espera (1 segundo en este caso) */
  137.     
  138. } /* Fin de la función MF_bucle_principal() */
  139.  
  140.  
  141.  
  142. /****************************************************************    */
  143. /* MF_InitToolbox                                                                                                 */
  144. /****************************************************************    */
  145. /*
  146.     Inicializa la Toolbox Macintosh. El orden de llamada a las diversas
  147.     rutinas es significativo! No lo cambie.
  148.  
  149.     Recibe:     nada
  150.     Cambia:      nada en la aplicación
  151.     Salida:      nada
  152. */
  153. void MF_InitToolbox (void)
  154. {
  155.  
  156.     InitGraf(&qd.thePort);
  157.     InitFonts();
  158.     FlushEvents(everyEvent,0);
  159.     InitWindows();
  160.     InitMenus();
  161.     TEInit();
  162.     InitDialogs(0L);
  163.     InitCursor();
  164.                                 
  165. } /* Fin de MF_InitToolbox() */
  166.  
  167.  
  168.     
  169. /****************************************************************    */
  170. /* MF_AbreMiVentana                                                       */
  171. /****************************************************************    */
  172. /*
  173.     Abre la ventana (la única) de nuestro programa. Las funciones empleadas
  174.     y el significado de los parámetros que utilizamos se comentarán en posteriores
  175.     versiones de esta aplicación.
  176.     
  177.     Recibe:     nada
  178.     Que hace: Crea una ventana...
  179.     Salida:      void (nada)
  180. */
  181. void MF_AbreMiVentana(void)
  182. {
  183. /* Declaración e inicialización de una variable de tipo Rect */                    
  184.     Rect    miRectangulo = { 48, 8,108, 300 };
  185.         
  186.     gMiVentana = NewWindow(    nil,
  187.                                                     &miRectangulo,
  188.                                                     "\pC de Cerca - 2",
  189.                                                     true,
  190.                                                     documentProc,
  191.                                                     (WindowPtr)-1L,
  192.                                                     false,
  193.                                                     nil);
  194.   
  195.   if(gMiVentana == nil) 
  196.           ExitToShell();    /* Si la creación de la ventana falla, 
  197.                                               posiblemente sea debido a falta de memoria libre
  198.                                               Lo más aconsejable es salir de la aplicación */
  199.       
  200. } /* Fin de MF_AbreMiVentana() */
  201.  
  202.  
  203.  
  204. /****************************************************************/
  205. /* MF_EscribeTexto                                                                                         */ 
  206. /****************************************************************/
  207. /*
  208.     Dibuja en nuestra ventana un texto.
  209.         
  210.     Recibe:     Un valor (short) que se emplea en una expresión condicional
  211.                         de tipo switch/case, para determinar qué texto escribir.
  212.     Cambia:      Borra los contenidos de la ventana y escribe un texto.
  213.     Salida:   nada
  214. */
  215. void MF_EscribeTexto(short codigo)
  216. {
  217.     SetPort(gMiVentana);    /* Antes de dibujar o escribir nada, debemos  */
  218.                                                  /* indicar al Sistema en que ventana deseamos */
  219.                                                  /* hacerlo */    
  220.                                                              
  221.     EraseRect(&gMiVentana->portRect); /* Borramos los contenidos */
  222.     MoveTo(10,30);                                        /* Y ajustamos la posición inicial */
  223.                                                                                  /* en la que vamos a escribir */
  224.              
  225.     /* Una expresión condicional del tipo switch...case */
  226.     switch(codigo) 
  227.     {
  228.          /* Según el valor del parámetro recibido (codigo) */
  229.          /* se ejecutará una (y sólo una) de las siguientes opciones. */
  230.          /* De hecho, se ejecuta el código comprendido entre las sentencias */
  231.          /* case y break */
  232.                  
  233.          case 0: /* Por ejemplo, si código = 0 */
  234.              DrawString("\pPulse el botón del ratón..."); /* <-- se ejecuta esto */
  235.              break; /* y el programa 'salta' hasta el final del switch */
  236.          case 1:
  237.              DrawString("\pSwitch-case nº 1. Pulse otra vez...");
  238.              break;
  239.          case 2:
  240.              DrawString("\pSwitch-case nº 2. Pulse una vez más...");
  241.              break;
  242.          case 3:
  243.              DrawString("\pSwitch-case nº 3. Esta ha sido la última...");
  244.              break;
  245.          default:
  246.              DrawString("\pMacFormat. C de Cerca nº 2");
  247.              break;
  248.                      
  249.      } /* Fin de switch(codigo) */
  250.  
  251. }/* Fin de MF_EscribeTexto() */